// 产品分类管理路由处理函数
// 该文件包含产品分类管理相关的所有业务逻辑处理函数

// 引入产品分类模型
const { product_categories: ProductCategory, products: Product } = require('../models/init-models')(require('../db').sequelize, require('sequelize').DataTypes);

/**
 * 获取产品分类列表（支持树形结构）
 * @param {Object} req - 请求对象
 * @param {Object} res - 响应对象
 * @returns {Promise<void>}
 */
const getCategoryList = async (req, res) => {
    try {
        // 获取所有产品分类
        const categories = await ProductCategory.findAll({
            order: [['category_id', 'ASC']]
        });

        // 构建树形结构
        const buildTree = (categories, parentId = null) => {
            return categories
                .filter(category => category.parent_id === parentId)
                .map(category => {
                    const children = buildTree(categories, category.category_id);
                    if (children.length > 0) {
                        return {
                            ...category.toJSON(),
                            children
                        };
                    }
                    return category.toJSON();
                });
        };

        const treeData = buildTree(categories);

        res.success(treeData, '获取产品分类列表成功');
    } catch (err) {
        console.error('获取产品分类列表失败:', err);
        res.error('获取产品分类列表失败');
    }
};

/**
 * 通过ID获取单个产品分类信息
 * @param {Object} req - 请求对象
 * @param {Object} res - 响应对象
 * @returns {Promise<void>}
 */
const getCategoryById = async (req, res) => {
    try {
        // 从请求参数中获取分类ID
        const categoryId = req.params.id;
        
        // 根据ID查找产品分类
        const category = await ProductCategory.findByPk(categoryId, {
            include: [{
                model: ProductCategory,
                as: 'children',
                attributes: ['category_id', 'category_name', 'description']
            }, {
                model: ProductCategory,
                as: 'parent',
                attributes: ['category_id', 'category_name', 'description']
            }]
        });

        // 如果产品分类不存在，返回404错误
        if (!category) {
            return res.error('产品分类不存在', 1, 404);
        }

        // 返回产品分类信息
        res.success(category, '获取产品分类信息成功');
    } catch (err) {
        console.error('获取产品分类信息失败:', err);
        res.error('获取产品分类信息失败');
    }
};

/**
 * 添加产品分类
 * @param {Object} req - 请求对象
 * @param {Object} res - 响应对象
 * @returns {Promise<void>}
 */
const addCategory = async (req, res) => {
    try {
        let { category_name, description, parent_id } = req.body;

        // 检查分类名称是否已存在
        const existingCategory = await ProductCategory.findOne({ where: { category_name } });
        if (existingCategory) {
            return res.error('分类名称已被占用，请更换其他名称', 1, 400);
        }

        // 如果父级ID未提供或为0，则设置为null表示顶级分类
        if (parent_id === undefined || parent_id === 0) {
            parent_id = null;
        }

        // 创建新产品分类
        const category = await ProductCategory.create({
            category_name,
            description,
            parent_id
        });
        
        // 返回成功响应
        res.success(category, '添加产品分类成功');
    } catch (err) {
        console.error('添加产品分类失败:', err);
        res.error('添加产品分类失败');
    }
};

/**
 * 更新产品分类信息
 * @param {Object} req - 请求对象
 * @param {Object} res - 响应对象
 * @returns {Promise<void>}
 */
const updateCategory = async (req, res) => {
    try {
        let { category_id, category_name, description, parent_id } = req.body;
        
        // 先查找产品分类是否存在
        const existingCategory = await ProductCategory.findByPk(category_id);
        if (!existingCategory) {
            return res.error('产品分类不存在', 1, 404);
        }

        // 检查分类名称是否已被其他分类使用
        if (category_name) {
            const { Op } = require('sequelize');
            const duplicateCategory = await ProductCategory.findOne({ 
                where: { 
                    category_name,
                    category_id: { [Op.ne]: category_id }
                } 
            });
            if (duplicateCategory) {
                return res.error('分类名称已被其他分类占用，请更换其他名称', 1, 400);
            }
        }

        // 如果父级ID未提供或为0，则设置为null表示顶级分类
        if (parent_id === undefined || parent_id === 0) {
            parent_id = null;
        }

        // 更新产品分类信息
        const [updatedCount] = await ProductCategory.update({
            category_name,
            description,
            parent_id
        }, {
            where: {
                category_id
            }
        });

        // 重新获取更新后的产品分类信息
        const updatedCategory = await ProductCategory.findByPk(category_id);

        // 返回成功响应
        res.success(updatedCategory, '更新产品分类成功');
    } catch (err) {
        console.error('更新产品分类失败:', err);
        res.error('更新产品分类失败');
    }
};

/**
 * 删除产品分类
 * @param {Object} req - 请求对象
 * @param {Object} res - 响应对象
 * @returns {Promise<void>}
 */
const delCategory = async (req, res) => {
    try {
        // 从请求参数中获取分类ID
        const categoryId = req.params.id;
        
        // 检查是否存在子分类
        const childCategories = await ProductCategory.count({
            where: { parent_id: categoryId }
        });
        
        if (childCategories > 0) {
            return res.error('该分类下存在子分类，不能直接删除', 1, 400);
        }
        
        // 检查是否有产品属于该分类
        const productCount = await Product.count({
            where: { category_id: categoryId }
        });
        
        if (productCount > 0) {
            return res.error('该分类下存在产品，不能直接删除', 1, 400);
        }
        
        // 删除产品分类
        const deletedCount = await ProductCategory.destroy({
            where: {
                category_id: categoryId
            }
        });
        
        // 如果没有删除任何记录，说明产品分类不存在
        if (deletedCount === 0) {
            return res.error('产品分类不存在', 1, 404);
        }
        
        // 返回成功响应
        res.success({ deletedCount }, '删除产品分类成功');
    } catch (err) {
        console.error('删除产品分类失败:', err);
        res.error('删除产品分类失败');
    }
};

// 导出所有路由处理函数
module.exports = {
    getCategoryById,   // 获取单个产品分类信息
    getCategoryList,   // 获取产品分类列表
    addCategory,       // 添加产品分类
    updateCategory,    // 更新产品分类信息
    delCategory        // 删除产品分类
};